package com.speedata

import android.annotation.SuppressLint
import android.app.Activity
import android.content.Context
import android.os.Bundle
import android.util.AttributeSet
import android.util.Log
import android.view.KeyEvent
import android.view.View
import android.widget.Button
import android.widget.Toast
import com.speedata.uhftest.R


import java.io.BufferedWriter
import java.io.File
import java.io.FileWriter
import java.io.IOException
import java.util.*
import kotlin.collections.ArrayList
import kotlin.math.exp

/**
 * @author xuyan 原主页面，联系kotlin部分。
 */
class MainActivity : Activity(), View.OnClickListener {

    private var bt1: Button? = null
    private var bt2: Button? = null
    private var bt3: Button? = null
    private var bt4: Button? = null
    private var bt5: Button? = null
    private var bt6: Button? = null

    private lateinit var bt7: Button

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        initView()


//        startActivity(Intent(this@MainActivity, SwitchXActivity::class.java))
//        finish()
//        main()
    }

    @SuppressLint("CutPasteId")
    private fun initView() {
        bt1 = findViewById(R.id.bt1)
        bt2 = findViewById(R.id.bt2)
        bt3 = findViewById(R.id.bt3)
        bt4 = findViewById(R.id.bt4)
        bt5 = findViewById(R.id.bt5)
        bt6 = findViewById(R.id.bt6)

        bt7 = findViewById(R.id.bt7)
        bt7.setOnClickListener(this)

        bt1!!.setOnClickListener(this)
        bt2!!.setOnClickListener(this)
        bt3!!.setOnClickListener(this)
        bt4!!.setOnClickListener(this)
        bt5!!.setOnClickListener(this)
        bt6!!.setOnClickListener(this)
    }

    override fun onClick(view: View) {
        when (view.id) {
            R.id.bt1 -> {
                open("11on")
                Toast.makeText(this, "11on", Toast.LENGTH_SHORT).show()
            }
            R.id.bt2 -> {
                open("11off")
                Toast.makeText(this, "11off", Toast.LENGTH_SHORT).show()
            }
            R.id.bt3 -> {
                open("3on")
                open("1on")
                Toast.makeText(this, "3on,1on", Toast.LENGTH_SHORT).show()
            }
            R.id.bt4 -> {
                open("1off")
                open("3off")
                Toast.makeText(this, "1off,3off", Toast.LENGTH_SHORT).show()
            }
            R.id.bt5 -> {
                open("0on")
                Toast.makeText(this, "0on", Toast.LENGTH_SHORT).show()
            }
            R.id.bt6 -> {
                open("0off")
                Toast.makeText(this, "0off", Toast.LENGTH_SHORT).show()
            }
            R.id.bt7 -> {
                main(arrayOf("1", "2", "3"))
            }
            else -> {
            }
        }

    }


    override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
        Toast.makeText(this@MainActivity, keyCode.toString(), Toast.LENGTH_SHORT).show()
        Log.d("onkeydown", keyCode.toString())
        return super.onKeyDown(keyCode, event)
    }

    companion object {

        /**
         * 补光灯
         * @param str
         */
        fun open(str: String) {
            Log.d("", "-print-rece-openCloseFlash $str start")
            val TorchFileName = File("/sys/class/misc/aw9523/gpio")
            //val TorchFileNames = File("/sys/class/misc/aw9523/gpios")
            //aw9523
            try {
                TorchFileWrite = BufferedWriter(FileWriter(TorchFileName, false))
                TorchFileWrite!!.write(str)
                TorchFileWrite!!.flush()
                TorchFileWrite!!.close()
                //TorchFileWrite!!.close()
            } catch (e: IOException) {
                e.printStackTrace()
                Log.d("", e.message)
            }

            Log.d("", "-print-rece-" + "openCloseFlash end")
        }

        private var TorchFileWrite: BufferedWriter? = null
        private lateinit var TorchFileWrites: BufferedWriter
    }

    //   fun test(a: Int, b: Int): Int = a + b

//    public fun printSum(a: Int, b: Int) {
//        print(a + b)
//        var a = 1
//        var s1 = "a is $a"
//        a = 2
//        val s2 = "${s1.replace("is", "was")}, but new is $a"
//        var age: String? = "23"
//        var ages = age!!.toInt()
//        val ages1 = age?.toInt()
//        val ages2 = age?.toInt() ?: -1
//
//    }

//    fun parseInt(str: String): Int? {
//
//        for (i in 1..4) print(i)
//
//        for (i in 4..1) print(i)
//
//        for (i in 1..10) {
//            println(i)
//        }
//
//        for (i in 1..4 step 2) print(i)
//
//        for (i in 4 downTo 1 step 2) print(i)
//
//        for (i in 1 until 10) {
//            print(i) // 排除10
//        }
//
//        //当 str 中的字符串内容不是一个整数时, 返回 null
//        return null
//    }

//    fun main(args: Array<String>) {
//        if (args.size < 2) {
//            print("Two integers expected")
//            return
//        }
//        val x = parseInt(args[0])
//        val y = parseInt(args[1])
//        if (x != null && y != null) {
//            print(x * y)
//        }
//    }
//
//
//    fun vars(vararg v: Int) {
//        for (vt in v) {
//            print(vt)
//        }
//
//        val oneMillion = 1_000_000
//        val creditCardNumber = 1234_5678_9012_3456L
//        val socialSecurityNumber = 210_2222_1999_0505_3939L
//        val hexBytes = 0xFF_EC_DE_5E
//        val bytes = 0b11010010_01101001_10010100_10010010
//
//    }

//    fun main(args: Array<String>) {
//        vars(1, 2, 3, 4, 5)
//        val sumLambda: (Int, Int) -> Int = { x, y -> x + y }
//        println(sumLambda(1, 2))
//        val c: Int
//        c = 1
//        var x = 5
//        x += 1
//    }

//    class Runoob {
//        val a: Int = 1
//        val b = 1
//        val ints = setOf(1, 2, 3)
//
////        fun foo(){
////            ints.forEach {
////                if (it == 0) return
////                print(it)
////            }
////        }
//
////        fun foo() {
////            ints.forEach lit@{
////                if (it == 0) return@lit
////                print(it)
////            }
////        }
//
////        fun foo(){
////            ints.forEach {
////                if (it == 0) return@forEach
////                print(it)
////            }
////        }
//
//        fun foo() {
//            ints.forEach(fun(value: Int) {
//                if (value == 0) return
//                print(value)
//            })
//        }
//
//
//    }

    //class Person constructor(firstName: String) {}

//    class Person(firstName: String) {
//
//    }

//    fun getStringLength(obj: Any): Int? {
//        if (obj is String) {
//            return obj.length
//        } else {
//            print("obj is Any")
//        }
//        if (obj !is Int) {
//
//        }
//        return null
//    }

//    fun getStringLength(obj: Any): Int? {
//        if (obj !is String) {
//            return null
//        }
//        return obj.length
//    }
//
//    fun getStringLength(obj: Any): Int? {
//        if (obj is String && obj.length > 0)
//            return obj.length
//        return null
//    }


//    fun main(args: Array<String>) {
//        print("循环输出：")
//        for (i in 1..4) print(i)
//        println(".................") //输出后加回车
//        for (i in 1 until 4) print(i)
//
//        for (i in 4 downTo 1 step 2) print(i)
//        println("\n..............")
//    }

//    fun main() {
//        val a: Int = 123
////        print(a === a)
////        val boxedA: Int? = a
////        val anotherBoxedA: Int? = a
////
////        print(boxedA === anotherBoxedA)
////        print(boxedA == anotherBoxedA)
////
////        val b: Byte = 1
////        val i: Int = b.toInt()
////        b.toDouble()
////        b.toShort()
////        b.toLong()
////        b.toFloat()
////        b.toDouble()
////        b.toChar()
////
////        val l = 1L + 3 //Long + int = Long
//
//        a.shl(1)
//        a.shr(1)
//        a.ushr(1)
//        a.and(1)
//        a.or(1)
//        a.xor(1)//异或
//        println(a.xor(1).toString())
//        a.inv()//反向
//        println(a.inv().toString())
//    }
//
//    fun decimaDigitValue(c: Char): Int {
//        if (c !in '0'..'9')
//            throw  IllegalArgumentException("Out of Range")
//        return c.toInt() - '0'.toInt()
//
//        val a = 1
//        val b = 2
//
//        //var max = a
//        //if (a < b) max = b
//
////        var max: Int
////        if (a > b) {
////            max = a
////        } else {
////            max = b
////        }
//
////        val max = if (a > b) a else b
//
//        val max = if (a > b) {
//            a
//        } else {
//            b
//        }
//
//        val c = if (true) a else b
//        val x = 5
//        when (x) {
//            1 -> print("")
//            2 -> print("")
//            else -> {
//                print("")
//            }
//
//        }
//
//        when (x) {
//            0, 1 -> print("")
//            else -> print("")
//        }
//
//        when (x) {
//            in 1..10 -> {
//                print("")
//            }
//            in 11..100 -> print("")
//            !in 100..200 -> print("")
//            else -> print("")
//        }
//        when {
//            x > 0 -> print("")
//            x < 0 -> print("")
//            else -> print("x = 0")
//        }
//
//        loop@ for (i in 1..10) {
//            for (j in 1..100) {
//                if (j == 10) break@loop
//            }
//        }
//
//
//    }


//    fun hasPrefix(x:Any) = when(x){
////        is String -> x.startsWith("prefix")
////        else -> false
//
//
//    }
//
//    fun main(args: Array<String>) {
//        //[1,2,3]
//        val a = arrayOf(1, 2, 3)
//        //[2,4,6]
//        val b = Array(3, { i -> (i * 2) })
//
//        println(a[0])
//        println(b[1])
//
//        val x: IntArray = intArrayOf(1, 2, 3)
//        x[0] = x[1] + x[2]
//        val str = "abcd"
//        for (c in str) {
//            print(c)
//        }
//    }

//    fun main(args: Array<String>) {
//        val text = """
//                  |徐
//                  |岩
//                  |帅
//        """.trimMargin("|")
//
//        println(text)
//    }

//    fun main(args: Array<String>) {
//        val i = 10
//        val s = "runoob"
//        val str = "$s.length is ${s.length}"
//        println(str)
//        val price = """
//            ${'$'}9.99
//        """.trimIndent()
//
//    }

//    fun main(args: Array<String>) {
//        var x = 0
//        if (x > 0) {
//
//        } else if (x == 0) {
//
//        } else {
//
//        }
//
//        var a = 1
//        var b = 2
//        var c = if (a > b) a else b
//        println("$c")
//
//    }
//
//    fun main(args: Array<String>){
//        val x = 5
//        val y = 9
//        if (x in 1..8){
//
//        }
//
//    }

//    fun main(args: Array<String>) {
//        var x = 0
//        when (x) {
//            0, 1 -> print("")
//            else -> print("")
//        }
//
//        when (x) {
//            1 -> print("")
//            else -> print("")
//        }
//
//        when (x) {
//            in 0..10 -> print("")
//            else -> print("")
//        }
//    }

//    fun main(args: Array<String>) {
//        val items = setOf("apple", "banana", "kiwi")
//        when {
//            "orange" in items -> print("")
//            "apple" in items -> print("")
//        }
//
//        val ints = setOf(1,2,3)
//
//        for (item in items) print(item)
//
//        for (item : Int in ints){
//
//        }
//
//        val array = setOf(1,2,3)
//
//        for (i in array.indices){
//
//        }
//
//        for ((index,value) in array.withIndex()) {
//            print("$index is $value")
//        }
//
//
//
//    }

//    fun main(args: Array<String>) {
//        val items = listOf("Apple", "Banana", "Kiwi")
//        for (item in items) {
//            print(item)
//        }
//
//        for (index in items.indices) {
//            print("$index is ${items[index]}")
//        }
//
//
//
//    }

//    fun main(args: Array<String>) {
//        print("------")
//        var x = 5
//        while (x > 0) {
//            print(x--)
//        }
//
//        print("------------")
//
//        var y = 5
//        do {
//            print(y--)
//        }while (y>0)
//
//
//
//    }

//    fun main(args: Array<String>) {
//        for (i in 1..10) {
//            if (i == 3) continue
//            print(i)
//            if (i > 5) break
//        }
//    }
//
//    class Person {
//
//        var lastName: String = "zhang"
//            @SuppressLint("DefaultLocale")
//            get() = field.toUpperCase()
//            set
//
////        var no: Int = 100
////            get() = field
////            set(value) {
////                if (value < 10) {
////                    field = value
////                } else {
////                    field = -1
////                }
////
////            }
//
//        var heiht: Float = 145.4f
//            private set
//
//        var no: Int = 100
//            get() = field
//            set(value) {
//                if (value < 10) {
//                    field = value
//                } else {
//                    field = -1
//                }
//            }
//
//
//    }

    //    fun main(args: Array<String>) {
//        var person: Person = Person()
//
//        person.lastName = "wang"
//
//        print("lastName:${person.lastName}")
//
//        person.no = 9
//        print("no:${person.no}")
//
//        person.no = 20
//        print("no:${person.no}")
//
//
//    }
//
//    public class MyTest {
//        lateinit var subject: TestSubject
//
//        @SetUp
//        fun setup() {
//            subject = TestSubject()
//        }
//
//        @Test
//        fun test() {
//            subject.method()
//        }
//
//    }
//
//    annotation class Test
//
//    annotation class SetUp
//
//    class TestSubject {
//            constructor(person: TestSubject) {
//
//        }
//        fun method() {
//
//        }
//
//    }

//    class DontCreateMe private constructor() {
//
//    }
//
//    class Customer(val customerName:String = "")
//
//
////    class Person constructor(firstName : String){
////        init {
////            print("$firstName")
////        }
////    }
////
//

//    class People(val firstName: String, val lastName: String) {
//        constructor(person: People) {
//            person.firstName = ""
//        }
//
//    }

//    class Runoob constructor(name: String) {
//        var url: String = "http://www.runoob.com"
//        var country: String = "CN"
//        var siteName = name
//
//        init {
//            print("${name}")
//        }
//
//        fun printTest() {
//
//        }
//
//
//
//    }
//
//    fun main(args: Array<String>) {
//        val runoob = Runoob("菜鸟教程")
//        print(runoob.country)
//        print(runoob.url)
//        print(runoob.siteName)
//        runoob.printTest()
//    }
//
//    class Runoob constructor(name: String) {
//        var url: String = "http://www.runoob.com"
//        var country: String = "CN"
//        var siteName = name
//
//        init {
//            println("初始化网站名: ${name}")
//        }
//
//        constructor(name: String, alexa: Int) : this(name) {
//            println("Alexa 排名 $alexa")
//        }
//
//        fun printTest() {
//            println("我是类的函数")
//        }
//
//    }
//
//    fun main(args: Array<String>) {
//        val runoob = Runoob("菜鸟教程", 10000)
//        println(runoob.siteName)
//        println(runoob.url)
//        println(runoob.country)
//        runoob.printTest()
//    }
//
//    open class Base{
//        open fun f(){}
//    }
//
//    abstract class Derived : Base(){
//        override abstract fun f()
//    }

//    class Outer{
//
//        private val bar:Int = 1
//        class Nested{
//            fun foo() = 2
//        }
//
//    }
//
//    fun main(args:Array<String>){
//        val demo = Outer.Nested().foo()
//        print(demo)
//    }

//    class Outer {
//        private val bar: Int = 1
//        var v = "成员属性"
//
//        inner class Inner {
//            fun foo() = bar
//            fun innerTest() {
//                var o = this@Outer
//                print("" + o.v)
//            }
//        }
//
//    }
//
//    fun main(args: Array<String>) {
//        val demo = Outer().Inner().foo()
//        print(demo)
//        val demo2 = Outer().Inner().innerTest()
//        print(demo2)
//    }

//    class Test {
//        var v = "成员属性"
//        fun setInterFace(test: TestInterFace) {
//            test.test()
//        }
//    }
//
//    interface TestInterFace {
//        fun test()
//    }
//
//    fun main(args: Array<String>) {
//        var test = Test()
//        test.setInterFace(object : TestInterFace {
//            override fun test() {
//                print("")
//            }
//        })
//    }
//
//    open class Base(p: Int)
//
//    class Derived(p: Int) : Base(p)

//    open class Person(var name : String, var age : Int){// 基类
//
//    }


//    class Student : Person {
//
//        constructor(ctx: Context) : super(ctx) {
//
//        }
//
//        constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs) {
//
//        }
//
//    }

//
//    open class Person(name: String) {
//        constructor(name: String, age: Int) : this(name) {
//            print("")
//        }
//
//        open fun study() {
//
//        }
//    }
//
//    //
//    class Student : Person {
//        constructor(name: String, age: Int, no: String, score: Int) : super(name, age) {
//
//        }
//
//        override fun study() {
//
//        }
//    }
//
//    //
//    fun main(args: Array<String>) {
//        var s = Student("Runoob", 18, "S12345", 89)
//
//        val c = C()
//        c.f()
//    }
//
//    open class A {
//        open fun f() {
//
//        }
//
//        fun a() {
//
//        }
//    }
//
//    interface B {
//        fun f() {}
//        fun b() {}
//    }
//
//    class C() : A(), B {
//        override fun f() {
//            super<A>.f()
//            super<B>.f()
//        }
//    }

//    open class Foo{
//        open val x:Int get() {
//            return 1
//        }
//    }
//
//    class Bar1:Foo(){
//        override val x : Int = 1
//    }

    //    interface Foo {
//        val count: Int
//    }
//
//    class Bar1(override val count: Int) : Foo
//
//    class Bar2 : Foo {
//        override val count: Int = 0
//    }
//
//    open class Person(var name: String, var age: Int) {
//        open var sex: String = "unknow"
//
//        init {
//
//        }
//
//
//    }
//
//    class Student(name: String, age: Int, var no: String,
//                  var score: Int) : Person(name, age) {
//        override var sex: String = ""
//
//    }

//    open class A {
//        open fun f() {}
//        fun a() {}
//    }
//
//    interface B {
//        fun f() {}
//        fun b() {}
//    }
//
//    class C : A(), B {
//        override fun f() {
//            super<A>.f()
//            super<B>.f()
//            print("")
//        }
//
//        var aaa: Int = 0
//            get() {
//                field
//                return 0
//            }
//            set(value) {}
//    }
//
//    interface MyInterface {
//        var name: String
//        fun bar()
//        fun foo() {
//            print("")
//        }
//    }
//
//    class MyImpl : MyInterface {
//        override var name: String = "runoob"
//        override fun bar() {
//            print("")
//
//        }
//    }
//
//    fun MutableList<Int>.swap(index1: Int, index2: Int) {
//        val tmp = this[index1]
//        this[index1] = this[index2]
//        this[index2] = tmp
//    }
//
//    fun main(args: Array<String>) {
//        val l = mutableListOf(1, 2, 3)
//        l.swap(0, 2)
//        print(l.toString())
//    }

    //    open class C
//
//    class D : C()
//
//    fun C.foo() = "c"
//
//    fun D.foo() = "d"
//
//    fun printFoo(c:C){
//        print(c.foo())
//    }
//
//    fun  main (args:Array<String>){
//        printFoo(D())
//    }
//
//    fun Any?.toString(): String {
//
//        if (this == null) {
//
//            return "null"
//        }
//        return toString()
//    }
//
//    fun main(arg: Array<String>) {
//        var t = null
//        print(t.toString())
//
//    }

//    class MyClass {
//        companion object {}
//    }
//
//    fun MyClass.Companion.foo() {
//        print("")
//    }
//
//    val MyClass.Companion.no: Int
//        get() = 10
//
//    fun main(args: Array<String>) {
//        print("${MyClass.no}")
//        MyClass.foo()
//    }


//    data class User(val name: String, val age: Int)
//
//    fun main(args: Array<String>) {
//        val jack = User(name = "jack", age = 1)
//        val olderJack = jack.copy(age = 2)
//        print(jack)
//        print(olderJack)
//
//        val jane = User("Jane", 35)
//        val (name, age) = jane
//        print("$name,$age")
//    }

//    sealed class Expr
//    data class Const(val number: Double) : Expr()
//    data class Sum(val e1: Expr, val e2: Expr) : Expr()
//    object NotANumber : Expr()

//    fun eval(expr: Expr): Double = when (expr) {
//        is Const -> expr.number
//        is Sum -> eval(expr.e1) + eval(expr.e2)
//        NotANumber -> Double.NaN
//    }

//    fun eval(expr: Expr): Double = when (expr) {
//        is Expr.Const -> expr.number
//        is Expr.Sum -> eval(expr.e1) + eval(expr.e2)
//        Expr.NotANumber -> Double.NaN
//    }

//    sealed class UiOp {
//        object Show : UiOp()
//        object Hide : UiOp()
//    }
//
//    fun execute(view: View, op: UiOp) = when (op) {
//        UiOp.Show -> view.visibility = View.VISIBLE
//        UiOp.Hide -> view.visibility = View.GONE
//    }
//
//    class Box<T>(t: T) {
//        var value = t
//        val box: Box<Int> = Box<Int>(1)
//        //val box = Box(1)
//
//    }
//
//    fun <T> doPrintLn(content: T) {
//        when (content) {
//            is Int -> print("$content")
//            is String -> print("${content.toUpperCase()}")
//            else -> print("")
//        }
//    }
//
//    fun <T : Comparable<T>> sort(list: List<T>) {
//        sort(listOf(1, 2, 3))
//        //sort(listOf(HashMap<Int,String>()))
//    }
//
//    fun <T> copyWhenGreater(list: List<T>, threshold: T): List<String>
//            where T : CharSequence, T : Comparable<T> {
//        return list.filter { it > threshold }.map { it.toString() }
//
//    }
//
//    class Runoob<in A>(a: A) {
//        fun foo(a: A) {
//
//        }
//    }
//
//    fun main(args: Array<String>) {
//        var strDCo = Runoob("a")
//        var anyDCo = Runoob<Any>("b")
//        strDCo = anyDCo
//    }

//    class A<T>(val t: T, val t2: T, val t3: T)
//    class Apple(var name: String)
//
//    fun main(args: Array<String>) {
//        val a1: A<*> = A(12, "String", Apple("苹果"))
//        val a2: A<Any?> = A(12, "String", Apple("苹果"))
//        val apple = a1.t3
//        print(apple)
//        val apple2 = apple as Apple
//        print(apple2.name)
//        val l: ArrayList<*> = arrayListOf("String", 1, 1.2f, Apple("苹果"))
//        for (item in l) {
//            print(item)
//        }
//
//
//    }


//    enum class Color {
//        RED, BLACK, BLUE, GREEN, WHITE
//    }
//
//    enum class Color(val rgb: Int) {
//        RED(0xFF0000),
//        GREEN(0x00FF00),
//        BLUE(0x0000FF)
//    }
//
//    enum class ProtocolState {
//
//        WAITING {
//            override fun signal() = TALKING
//        },
//
//        TALKING {
//            override fun signal() = WAITING
//        };
//
//        abstract fun signal(): ProtocolState
//    }
//
//    enum class RGB {
//        RED, BLACK, BLUE, GREEN, WHITE
//    }
//
////    fun main(args: ArrayList<String>) {
////        var color: Color = Color.BLUE
////    }
//
//    inline fun <reified T : Enum<T>> printAllValues() {
//        print(enumValues<T>().joinToString { it.name })
//    }
//
//    fun main(args: ArrayList<String>){
//        printAllValues<RGB>()
//    }

//    open class A(x: Int) {
//        public open val y: Int = x
//    }
//
//    interface B {}
//
//    val ab: A = object : A(1), B {
//        override val y = 15
//    }
//
//    class C {
//        private fun foo() = object {
//            val x: String = "x"
//        }
//
//        fun publicFoo() = object {
//            val x: String = "x"
//        }
//
//        fun bar() {
//            val x1 = foo().x
//            //val x2 = publicFoo().x
//        }
//    }
//
//    object Site {
//        var url: String = ""
//        val name: String = "cainiao"
//    }
//
//    fun main(args: ArrayList<String>) {
//        var s1 = Site
//        var s2 = Site
//        s1.url = "www"
//        print(s1.url)
//    }

//    object DefaultListener : MouseAdapter() {
//
//    }

//    class Site {
//        var name = "cainiao"
//
//        object DeskTop {
//            var url = "www"
//            fun showName() {
//                //print("$name")
//            }
//        }
//    }

    interface Base {
        fun print()
    }

    class BaseImpl(val x: Int) : Base {
        override fun print() {
            print(x)
        }
    }

    class Derived(b: Base) : Base by b

    fun main(args: Array<String>) {
        val b = BaseImpl(10)
        Derived(b).print()
    }

    fun sum(a: Int, b: Int): Int = a + b

    fun printSum(a: Int, b: Int) {
        print(a + b)
    }

    fun greet(name: String) {
        println("hello, $name")
    }

    fun test() {

    }

    class Runoob {

    }

    public fun printSum2(a: Int, b: Int): Unit {
        print(a + b)
    }

}




